home *** CD-ROM | disk | FTP | other *** search
/ Language/OS - Multiplatform Resource Library / LANGUAGE OS.iso / cocktail / cg.lha / cg / m2c / Dialog.c < prev    next >
C/C++ Source or Header  |  1992-11-24  |  22KB  |  721 lines
  1. #include "SYSTEM_.h"
  2.  
  3. #ifndef DEFINITION_DynArray
  4. #include "DynArray.h"
  5. #endif
  6.  
  7. #ifndef DEFINITION_IO
  8. #include "IO.h"
  9. #endif
  10.  
  11. #ifndef DEFINITION_Strings
  12. #include "Strings.h"
  13. #endif
  14.  
  15. #ifndef DEFINITION_Idents
  16. #include "Idents.h"
  17. #endif
  18.  
  19. #ifndef DEFINITION_Sets
  20. #include "Sets.h"
  21. #endif
  22.  
  23. #ifndef DEFINITION_Relations
  24. #include "Relations.h"
  25. #endif
  26.  
  27. #ifndef DEFINITION_Tree
  28. #include "Tree.h"
  29. #endif
  30.  
  31. #ifndef DEFINITION_Order
  32. #include "Order.h"
  33. #endif
  34.  
  35. #ifndef DEFINITION_Tree
  36. #include "Tree.h"
  37. #endif
  38.  
  39. #ifndef DEFINITION_Dialog
  40. #include "Dialog.h"
  41. #endif
  42.  
  43.  
  44. typedef struct S_1 {
  45.     SHORTCARD C_0_A, B;
  46.     Tree_tTree Rule;
  47. } tDepend;
  48. static Sets_tSet Cyclics;
  49. static SHORTCARD ClassCount;
  50. static Strings_tString String;
  51. static LONGINT MarkSize;
  52. static struct S_2 {
  53.     tDepend A[10000 + 1];
  54. } *MarkPtr;
  55. static INTEGER MarkCount;
  56. static LONGINT TraceSize;
  57. static struct S_3 {
  58.     tDepend A[10000 + 1];
  59. } *TracePtr;
  60. static INTEGER TraceCount;
  61. static BOOLEAN Find ARGS((SHORTCARD a, SHORTCARD b, Tree_tTree rule));
  62. static BOOLEAN ForallClasses ARGS((Tree_tTree t));
  63. static BOOLEAN ForallAttributes ARGS((Tree_tTree t));
  64. static void FindPath ARGS((SHORTCARD a, SHORTCARD b, Tree_tTree rule));
  65. static void Menue ARGS(());
  66. struct S_4 {
  67.     CHAR A[64 + 1];
  68. };
  69.  
  70. static Tree_tTree *G_1_UserClass;
  71. static Tree_tTree *G_2_rule;
  72. static SHORTCARD *G_3_b;
  73. static SHORTCARD *G_4_a;
  74.  
  75. static BOOLEAN ForallClasses
  76. # ifdef __STDC__
  77. (Tree_tTree t)
  78. # else
  79. (t)
  80. Tree_tTree t;
  81. # endif
  82. {
  83.   if (t->U_1.V_1.Kind == Tree_Class) {
  84.     {
  85.       register Tree_yClass *W_1 = &(*G_2_rule)->U_1.V_5.Class;
  86.  
  87.       {
  88.         register Tree_yChild *W_2 = &W_1->Instance->A[*G_4_a - 1].Selector->U_1.V_9.Child;
  89.  
  90.         if (Find(*G_4_a - W_1->AttrCount - W_2->InstOffset, *G_3_b - W_1->AttrCount - W_2->InstOffset, t)) {
  91.           return TRUE;
  92.         }
  93.       }
  94.     }
  95.     if (ForallClasses(t->U_1.V_5.Class.Extensions)) {
  96.       return TRUE;
  97.     }
  98.     return ForallClasses(t->U_1.V_5.Class.Next);
  99.   } else {
  100.     return FALSE;
  101.   }
  102. }
  103.  
  104. static BOOLEAN ForallAttributes
  105. # ifdef __STDC__
  106. (Tree_tTree t)
  107. # else
  108. (t)
  109. Tree_tTree t;
  110. # endif
  111. {
  112.   switch (t->U_1.V_1.Kind) {
  113.   case Tree_Class:;
  114.     if (ForallAttributes(t->U_1.V_5.Class.BaseClass)) {
  115.       return TRUE;
  116.     } else {
  117.       return ForallAttributes(t->U_1.V_5.Class.Attributes);
  118.     }
  119.     break;
  120.   case Tree_Child:;
  121.     {
  122.       register Tree_yClass *W_3 = &(*G_1_UserClass)->U_1.V_5.Class;
  123.  
  124.       {
  125.         register Tree_yChild *W_4 = &t->U_1.V_9.Child;
  126.  
  127.         if (W_4->Class == *G_2_rule && Find(W_3->AttrCount + W_4->InstOffset + *G_4_a, W_3->AttrCount + W_4->InstOffset + *G_3_b, *G_1_UserClass)) {
  128.           return TRUE;
  129.         }
  130.       }
  131.     }
  132.     return ForallAttributes(t->U_1.V_9.Child.Next);
  133.     break;
  134.   case Tree_Attribute:;
  135.     return ForallAttributes(t->U_1.V_10.Attribute.Next);
  136.     break;
  137.   case Tree_ActionPart:;
  138.     return ForallAttributes(t->U_1.V_11.ActionPart.Next);
  139.     break;
  140.   default :
  141.     return FALSE;
  142.     break;
  143.   }
  144. }
  145.  
  146. static BOOLEAN Find
  147. # ifdef __STDC__
  148. (SHORTCARD a, SHORTCARD b, Tree_tTree rule)
  149. # else
  150. (a, b, rule)
  151. SHORTCARD a, b;
  152. Tree_tTree rule;
  153. # endif
  154. {
  155.   SHORTCARD c, UserIndex;
  156.   INTEGER i, markCount, traceCount;
  157.   Relations_tRelation DPClosure;
  158.   Tree_tTree UserClass;
  159.   Tree_tTree *L_1;
  160.   Tree_tTree *L_2;
  161.   SHORTCARD *L_3;
  162.   SHORTCARD *L_4;
  163.  
  164.   L_1 = G_1_UserClass;
  165.   G_1_UserClass = &UserClass;
  166.   L_2 = G_2_rule;
  167.   G_2_rule = &rule;
  168.   L_3 = G_3_b;
  169.   G_3_b = &b;
  170.   L_4 = G_4_a;
  171.   G_4_a = &a;
  172.   {
  173.     register Tree_yClass *W_5 = &rule->U_1.V_5.Class;
  174.  
  175.     if (!(IN(Tree_cSNC, Tree_GrammarClass) && Relations_IsRelated((LONGINT)a, (LONGINT)b, W_5->DNC) || IN(Tree_cLNC, Tree_GrammarClass) && Relations_IsRelated((LONGINT)a, (LONGINT)b, W_5->SNC))) {
  176.       G_1_UserClass = L_1;
  177.       G_2_rule = L_2;
  178.       G_3_b = L_3;
  179.       G_4_a = L_4;
  180.       return FALSE;
  181.     }
  182.     {
  183.       LONGINT B_1 = 1, B_2 = MarkCount;
  184.  
  185.       if (B_1 <= B_2)
  186.         for (i = B_1;; i += 1) {
  187.           {
  188.             register tDepend *W_6 = &MarkPtr->A[i];
  189.  
  190.             if (a == W_6->C_0_A && b == W_6->B && rule == W_6->Rule) {
  191.               G_1_UserClass = L_1;
  192.               G_2_rule = L_2;
  193.               G_3_b = L_3;
  194.               G_4_a = L_4;
  195.               return FALSE;
  196.             }
  197.           }
  198.           if (i >= B_2) break;
  199.         }
  200.     }
  201.     INC(MarkCount);
  202.     if (MarkCount == MarkSize) {
  203.       DynArray_ExtendArray((ADDRESS *)&MarkPtr, &MarkSize, (LONGINT)sizeof(tDepend));
  204.     }
  205.     {
  206.       register tDepend *W_7 = &MarkPtr->A[MarkCount];
  207.  
  208.       W_7->C_0_A = a;
  209.       W_7->B = b;
  210.       W_7->Rule = rule;
  211.     }
  212.     markCount = MarkCount;
  213.     traceCount = TraceCount;
  214.     Relations_MakeRelation(&DPClosure, (LONGINT)W_5->InstCount, (LONGINT)W_5->InstCount);
  215.     Relations_Assign(&DPClosure, W_5->DP);
  216.     Relations_Closure(&DPClosure);
  217.     if (Relations_IsRelated((LONGINT)a, (LONGINT)b, DPClosure)) {
  218.       {
  219.         SHORTCARD B_3 = 1, B_4 = W_5->InstCount;
  220.  
  221.         if (B_3 <= B_4)
  222.           for (c = B_3;; c += 1) {
  223.             if (Relations_IsRelated((LONGINT)a, (LONGINT)c, W_5->DP) && (Relations_IsRelated((LONGINT)c, (LONGINT)b, DPClosure) || c == b)) {
  224.               INC(TraceCount);
  225.               if (TraceCount == TraceSize) {
  226.                 DynArray_ExtendArray((ADDRESS *)&TracePtr, &TraceSize, (LONGINT)sizeof(tDepend));
  227.               }
  228.               {
  229.                 register tDepend *W_8 = &TracePtr->A[TraceCount];
  230.  
  231.                 W_8->C_0_A = a;
  232.                 W_8->B = c;
  233.                 W_8->Rule = rule;
  234.               }
  235.               Relations_ReleaseRelation(&DPClosure);
  236.               {
  237.                 BOOLEAN R_1 = c == b || Find(c, b, rule);
  238.  
  239.                 G_1_UserClass = L_1;
  240.                 G_2_rule = L_2;
  241.                 G_3_b = L_3;
  242.                 G_4_a = L_4;
  243.                 return R_1;
  244.               }
  245.             }
  246.             if (c >= B_4) break;
  247.           }
  248.       }
  249.     }
  250.     Relations_ReleaseRelation(&DPClosure);
  251.     if (IN(Tree_Right, W_5->Instance->A[a - 1].Properties) && IN(Tree_Right, W_5->Instance->A[b - 1].Properties) && W_5->Instance->A[a - 1].Selector == W_5->Instance->A[b - 1].Selector && W_5->Instance->A[a - 1].Selector != Tree_NoTree) {
  252.       {
  253.         register Tree_yChild *W_9 = &W_5->Instance->A[a - 1].Selector->U_1.V_9.Child;
  254.  
  255.         if (Find(a - W_5->AttrCount - W_9->InstOffset, b - W_5->AttrCount - W_9->InstOffset, W_9->Class)) {
  256.           G_1_UserClass = L_1;
  257.           G_2_rule = L_2;
  258.           G_3_b = L_3;
  259.           G_4_a = L_4;
  260.           return TRUE;
  261.         }
  262.         if (ForallClasses(W_9->Class->U_1.V_5.Class.Extensions)) {
  263.           G_1_UserClass = L_1;
  264.           G_2_rule = L_2;
  265.           G_3_b = L_3;
  266.           G_4_a = L_4;
  267.           return TRUE;
  268.         }
  269.       }
  270.     }
  271.     if (IN(Tree_Left, W_5->Instance->A[a - 1].Properties) && IN(Tree_Left, W_5->Instance->A[b - 1].Properties)) {
  272.       {
  273.         SHORTCARD B_5 = 1, B_6 = ClassCount;
  274.  
  275.         if (B_5 <= B_6)
  276.           for (UserIndex = B_5;; UserIndex += 1) {
  277.             if (Sets_IsElement((LONGCARD)UserIndex, &W_5->Users)) {
  278.               UserClass = Order_IndexToClass->A[UserIndex];
  279.               if (ForallAttributes(UserClass)) {
  280.                 G_1_UserClass = L_1;
  281.                 G_2_rule = L_2;
  282.                 G_3_b = L_3;
  283.                 G_4_a = L_4;
  284.                 return TRUE;
  285.               }
  286.             }
  287.             if (UserIndex >= B_6) break;
  288.           }
  289.       }
  290.     }
  291.     if (IN(Tree_cLNC, Tree_GrammarClass)) {
  292.       {
  293.         SHORTCARD B_7 = 1, B_8 = W_5->InstCount;
  294.  
  295.         if (B_7 <= B_8)
  296.           for (c = B_7;; c += 1) {
  297.             if (Relations_IsRelated((LONGINT)a, (LONGINT)c, W_5->SNC) && Relations_IsRelated((LONGINT)c, (LONGINT)b, W_5->SNC) && Find(a, c, rule) && Find(c, b, rule)) {
  298.               G_1_UserClass = L_1;
  299.               G_2_rule = L_2;
  300.               G_3_b = L_3;
  301.               G_4_a = L_4;
  302.               return TRUE;
  303.             }
  304.             if (c >= B_8) break;
  305.           }
  306.       }
  307.     }
  308.     if (IN(Tree_cSNC, Tree_GrammarClass)) {
  309.       {
  310.         SHORTCARD B_9 = 1, B_10 = W_5->InstCount;
  311.  
  312.         if (B_9 <= B_10)
  313.           for (c = B_9;; c += 1) {
  314.             if (Relations_IsRelated((LONGINT)a, (LONGINT)c, W_5->DNC) && Relations_IsRelated((LONGINT)c, (LONGINT)b, W_5->DNC) && Find(a, c, rule) && Find(c, b, rule)) {
  315.               G_1_UserClass = L_1;
  316.               G_2_rule = L_2;
  317.               G_3_b = L_3;
  318.               G_4_a = L_4;
  319.               return TRUE;
  320.             }
  321.             if (c >= B_10) break;
  322.           }
  323.       }
  324.     }
  325.     MarkCount = markCount;
  326.     TraceCount = traceCount;
  327.     G_1_UserClass = L_1;
  328.     G_2_rule = L_2;
  329.     G_3_b = L_3;
  330.     G_4_a = L_4;
  331.     return FALSE;
  332.   }
  333. }
  334.  
  335. static void FindPath
  336. # ifdef __STDC__
  337. (SHORTCARD a, SHORTCARD b, Tree_tTree rule)
  338. # else
  339. (a, b, rule)
  340. SHORTCARD a, b;
  341. Tree_tTree rule;
  342. # endif
  343. {
  344.   INTEGER i;
  345.  
  346.   {
  347.     register Tree_yClass *W_10 = &rule->U_1.V_5.Class;
  348.  
  349.     Idents_WriteIdent((System_tFile)IO_StdOutput, W_10->Name);
  350.     IO_WriteS((System_tFile)IO_StdOutput, (STRING)"    ", 1L);
  351.     Tree_WriteName(W_10->Instance->A[a - 1]);
  352.     IO_WriteS((System_tFile)IO_StdOutput, (STRING)"    ", 1L);
  353.     Tree_WriteName(W_10->Instance->A[b - 1]);
  354.     IO_WriteNl((System_tFile)IO_StdOutput);
  355.     IO_WriteNl((System_tFile)IO_StdOutput);
  356.   }
  357.   MarkSize = 32;
  358.   DynArray_MakeArray((ADDRESS *)&MarkPtr, &MarkSize, (LONGINT)sizeof(tDepend));
  359.   MarkCount = 0;
  360.   TraceSize = 32;
  361.   DynArray_MakeArray((ADDRESS *)&TracePtr, &TraceSize, (LONGINT)sizeof(tDepend));
  362.   TraceCount = 0;
  363.   if (Find(a, b, rule)) {
  364.     {
  365.       LONGINT B_11 = 1, B_12 = TraceCount;
  366.  
  367.       if (B_11 <= B_12)
  368.         for (i = B_11;; i += 1) {
  369.           {
  370.             register tDepend *W_11 = &TracePtr->A[i];
  371.  
  372.             Idents_WriteIdent((System_tFile)IO_StdOutput, W_11->Rule->U_1.V_5.Class.Name);
  373.             IO_WriteS((System_tFile)IO_StdOutput, (STRING)"    ", 1L);
  374.             Tree_WriteName(W_11->Rule->U_1.V_5.Class.Instance->A[W_11->C_0_A - 1]);
  375.             IO_WriteS((System_tFile)IO_StdOutput, (STRING)"    ", 1L);
  376.             Tree_WriteName(W_11->Rule->U_1.V_5.Class.Instance->A[W_11->B - 1]);
  377.             IO_WriteNl((System_tFile)IO_StdOutput);
  378.           }
  379.           if (i >= B_12) break;
  380.         }
  381.     }
  382.   }
  383.   DynArray_ReleaseArray((ADDRESS *)&MarkPtr, &MarkSize, (LONGINT)sizeof(tDepend));
  384.   DynArray_ReleaseArray((ADDRESS *)&TracePtr, &TraceSize, (LONGINT)sizeof(tDepend));
  385. }
  386.  
  387. static void Menue
  388. # ifdef __STDC__
  389. ()
  390. # else
  391. ()
  392. # endif
  393. {
  394.   Tree_f = IO_StdOutput;
  395.   IO_WriteNl(Tree_f);
  396.   IO_WriteS(Tree_f, (STRING)" Dialog System", 14L);
  397.   IO_WriteNl(Tree_f);
  398.   IO_WriteNl(Tree_f);
  399.   IO_WriteS(Tree_f, (STRING)"   <name>          select current node type (rule)", 50L);
  400.   IO_WriteNl(Tree_f);
  401.   IO_WriteS(Tree_f, (STRING)" t <name>          select current node type (rule)", 50L);
  402.   IO_WriteNl(Tree_f);
  403.   IO_WriteS(Tree_f, (STRING)" a <name>[:<name>] select current attribute instance a", 54L);
  404.   IO_WriteNl(Tree_f);
  405.   IO_WriteS(Tree_f, (STRING)" b <name>[:<name>] select current attribute instance b", 54L);
  406.   IO_WriteNl(Tree_f);
  407.   IO_WriteNl(Tree_f);
  408.   IO_WriteS(Tree_f, (STRING)" P print dependency relation DP  for complete node type", 55L);
  409.   IO_WriteNl(Tree_f);
  410.   IO_WriteS(Tree_f, (STRING)" p print dependency relation DP  for current attribute instance", 63L);
  411.   IO_WriteNl(Tree_f);
  412.   IO_WriteS(Tree_f, (STRING)" S print dependency relation SNC for complete node type", 55L);
  413.   IO_WriteNl(Tree_f);
  414.   IO_WriteS(Tree_f, (STRING)" s print dependency relation SNC for current attribute instance", 63L);
  415.   IO_WriteNl(Tree_f);
  416.   IO_WriteS(Tree_f, (STRING)" N print dependency relation DNC for complete node type", 55L);
  417.   IO_WriteNl(Tree_f);
  418.   IO_WriteS(Tree_f, (STRING)" n print dependency relation DNC for current attribute instance", 63L);
  419.   IO_WriteNl(Tree_f);
  420.   IO_WriteS(Tree_f, (STRING)" O print dependency relation OAG for complete node type", 55L);
  421.   IO_WriteNl(Tree_f);
  422.   IO_WriteS(Tree_f, (STRING)" o print dependency relation OAG for current attribute instance", 63L);
  423.   IO_WriteNl(Tree_f);
  424.   IO_WriteS(Tree_f, (STRING)" C print dependencies introduced for total order for complete node type", 71L);
  425.   IO_WriteNl(Tree_f);
  426.   IO_WriteS(Tree_f, (STRING)" c print dependencies introduced for total order for cyclic attributes", 70L);
  427.   IO_WriteNl(Tree_f);
  428.   IO_WriteS(Tree_f, (STRING)" G print attribute instances sorted by declaration order", 56L);
  429.   IO_WriteNl(Tree_f);
  430.   IO_WriteS(Tree_f, (STRING)" E print attribute instances sorted by evaluation order", 55L);
  431.   IO_WriteNl(Tree_f);
  432.   IO_WriteS(Tree_f, (STRING)" V print visit sequence", 23L);
  433.   IO_WriteNl(Tree_f);
  434.   IO_WriteS(Tree_f, (STRING)" F search for and print dependency path between attributes a and b", 66L);
  435.   IO_WriteNl(Tree_f);
  436.   IO_WriteS(Tree_f, (STRING)" M print summary of node type (rule) from source", 48L);
  437.   IO_WriteNl(Tree_f);
  438.   IO_WriteS(Tree_f, (STRING)" Q browse internal data structure of complete attribute grammar", 63L);
  439.   IO_WriteNl(Tree_f);
  440.   IO_WriteS(Tree_f, (STRING)" q browse internal data structure of current node type", 54L);
  441.   IO_WriteNl(Tree_f);
  442.   IO_WriteS(Tree_f, (STRING)" h print menue for dialog system", 32L);
  443.   IO_WriteNl(Tree_f);
  444.   IO_WriteS(Tree_f, (STRING)" ? print current state", 22L);
  445.   IO_WriteNl(Tree_f);
  446.   IO_WriteS(Tree_f, (STRING)" x exit dialog system", 21L);
  447.   IO_WriteNl(Tree_f);
  448.   IO_WriteNl(Tree_f);
  449. }
  450.  
  451. void Dialog_Dialog
  452. # ifdef __STDC__
  453. (Tree_tTree t)
  454. # else
  455. (t)
  456. Tree_tTree t;
  457. # endif
  458. {
  459.   CHAR Com, Ch;
  460.   Tree_tTree Class, ChildsClass;
  461.   Tree_tTree Attribute;
  462.   struct S_4 Name0, Name1, Name2;
  463.   INTEGER Length0, Length1, Length2;
  464.   Idents_tIdent Ident;
  465.   SHORTCARD a, b, Offset;
  466.  
  467.   Menue();
  468.   Class = Tree_NoTree;
  469.   a = 0;
  470.   b = 0;
  471.   for (;;) {
  472.     IO_WriteS((System_tFile)IO_StdOutput, (STRING)"? ", 2L);
  473.     Ch = IO_ReadC((System_tFile)IO_StdInput);
  474.     Length0 = -1;
  475.     while (Ch > ' ' && Ch != ':') {
  476.       INC(Length0);
  477.       Name0.A[Length0] = Ch;
  478.       Ch = IO_ReadC((System_tFile)IO_StdInput);
  479.     }
  480.     Name0.A[Length0 + 1] = '\0';
  481.     while (Ch <= ' ' && Ch != '\n' || Ch == ':') {
  482.       Ch = IO_ReadC((System_tFile)IO_StdInput);
  483.     }
  484.     Length1 = -1;
  485.     while (Ch > ' ' && Ch != ':') {
  486.       INC(Length1);
  487.       Name1.A[Length1] = Ch;
  488.       Ch = IO_ReadC((System_tFile)IO_StdInput);
  489.     }
  490.     Name1.A[Length1 + 1] = '\0';
  491.     while (Ch <= ' ' && Ch != '\n' || Ch == ':') {
  492.       Ch = IO_ReadC((System_tFile)IO_StdInput);
  493.     }
  494.     Length2 = -1;
  495.     while (Ch > ' ' && Ch != ':') {
  496.       INC(Length2);
  497.       Name2.A[Length2] = Ch;
  498.       Ch = IO_ReadC((System_tFile)IO_StdInput);
  499.     }
  500.     Name2.A[Length2 + 1] = '\0';
  501.     while (Ch != '\n') {
  502.       Ch = IO_ReadC((System_tFile)IO_StdInput);
  503.     }
  504.     if (Length0 == 0) {
  505.       Com = Name0.A[0];
  506.       switch (Com) {
  507.       case 't':;
  508.       case 'T':;
  509.         Strings_ArrayToString(Name1.A, 65L, &String);
  510.         Ident = Idents_MakeIdent(&String);
  511.         Class = Tree_IdentifyClass(t->U_1.V_26.Ag.Classes, Ident);
  512.         if (Class == Tree_NoTree) {
  513.           IO_WriteS((System_tFile)IO_StdOutput, (STRING)"unknown node type: ", 19L);
  514.           Strings_WriteL((System_tFile)IO_StdOutput, &String);
  515.         }
  516.         break;
  517.       case 'a':;
  518.       case 'A':;
  519.       case 'b':;
  520.       case 'B':;
  521.         Strings_ArrayToString(Name1.A, 65L, &String);
  522.         Ident = Idents_MakeIdent(&String);
  523.         Attribute = Tree_IdentifyAttribute(Class, Ident);
  524.         if (Attribute == Tree_NoTree) {
  525.           IO_WriteS((System_tFile)IO_StdOutput, (STRING)"unknown attribute: ", 19L);
  526.           Strings_WriteL((System_tFile)IO_StdOutput, &String);
  527.         } else {
  528.           if (Com == 'a' || Com == 'A') {
  529.             a = Attribute->U_1.V_9.Child.AttrIndex;
  530.           } else {
  531.             b = Attribute->U_1.V_9.Child.AttrIndex;
  532.           }
  533.           if (Length2 >= 0) {
  534.             ChildsClass = Attribute->U_1.V_9.Child.Class;
  535.             if (ChildsClass != Tree_NoTree) {
  536.               Strings_ArrayToString(Name2.A, 65L, &String);
  537.               Ident = Idents_MakeIdent(&String);
  538.               Offset = Class->U_1.V_5.Class.AttrCount + Attribute->U_1.V_9.Child.InstOffset;
  539.               Attribute = Tree_IdentifyAttribute(ChildsClass, Ident);
  540.               if (Attribute == Tree_NoTree) {
  541.                 IO_WriteS((System_tFile)IO_StdOutput, (STRING)"unknown attribute: ", 19L);
  542.                 Strings_WriteL((System_tFile)IO_StdOutput, &String);
  543.               } else {
  544.                 if (Com == 'a' || Com == 'A') {
  545.                   a = Offset + Attribute->U_1.V_9.Child.AttrIndex;
  546.                 } else {
  547.                   b = Offset + Attribute->U_1.V_9.Child.AttrIndex;
  548.                 }
  549.               }
  550.             }
  551.           }
  552.         }
  553.         break;
  554.       case 'P':;
  555.         Tree_WriteDependencies(Class, Class->U_1.V_5.Class.DP, Tree_MaxSet);
  556.         break;
  557.       case 'p':;
  558.         Tree_WriteDependencies(Class, Class->U_1.V_5.Class.DP, Tree_MaxSet);
  559.         break;
  560.       case 'S':;
  561.         Tree_WriteDependencies(Class, Class->U_1.V_5.Class.SNC, Tree_MaxSet);
  562.         break;
  563.       case 's':;
  564.         Tree_WriteDependencies(Class, Class->U_1.V_5.Class.SNC, Tree_MaxSet);
  565.         break;
  566.       case 'N':;
  567.         Tree_WriteDependencies(Class, Class->U_1.V_5.Class.DNC, Tree_MaxSet);
  568.         break;
  569.       case 'n':;
  570.         Tree_WriteDependencies(Class, Class->U_1.V_5.Class.DNC, Tree_MaxSet);
  571.         break;
  572.       case 'O':;
  573.         Tree_WriteDependencies(Class, Class->U_1.V_5.Class.OAG, Tree_MaxSet);
  574.         break;
  575.       case 'o':;
  576.         Tree_WriteDependencies(Class, Class->U_1.V_5.Class.OAG, Tree_MaxSet);
  577.         break;
  578.       case 'C':;
  579.         if (Class != Tree_NoTree && IN(Tree_cDNC, Tree_GrammarClass)) {
  580.           {
  581.             register Tree_yClass *W_12 = &Class->U_1.V_5.Class;
  582.  
  583.             Relations_MakeRelation(&W_12->Part, (LONGINT)W_12->InstCount, (LONGINT)W_12->InstCount);
  584.             Relations_Assign(&W_12->Part, W_12->OAG);
  585.             Relations_Difference(&W_12->Part, W_12->DNC);
  586.             Tree_WriteDependencies(Class, W_12->Part, Tree_MaxSet);
  587.             IO_WriteNl((System_tFile)IO_StdOutput);
  588.             Relations_ReleaseRelation(&W_12->Part);
  589.           }
  590.         }
  591.         break;
  592.       case 'c':;
  593.         if (Class != Tree_NoTree && IN(Tree_cDNC, Tree_GrammarClass)) {
  594.           {
  595.             register Tree_yClass *W_13 = &Class->U_1.V_5.Class;
  596.  
  597.             Relations_MakeRelation(&W_13->Part, (LONGINT)W_13->InstCount, (LONGINT)W_13->InstCount);
  598.             Sets_MakeSet(&Cyclics, (LONGCARD)W_13->InstCount);
  599.             Relations_GetCyclics(W_13->OAG, &Cyclics);
  600.             Relations_Assign(&W_13->Part, W_13->OAG);
  601.             Relations_Difference(&W_13->Part, W_13->DNC);
  602.             Tree_WriteDependencies(Class, W_13->Part, Cyclics);
  603.             Relations_ReleaseRelation(&W_13->Part);
  604.             Sets_ReleaseSet(&Cyclics);
  605.           }
  606.         }
  607.         break;
  608.       case 'D':;
  609.       case 'd':;
  610.       case 'G':;
  611.       case 'g':;
  612.         Order_WriteOrderDecl(Class);
  613.         break;
  614.       case 'E':;
  615.       case 'e':;
  616.         if (IN(Tree_cOAG, Tree_GrammarClass)) {
  617.           Order_WriteOrderEval(Class);
  618.         }
  619.         break;
  620.       case 'V':;
  621.       case 'v':;
  622.         if (IN(Tree_cOAG, Tree_GrammarClass)) {
  623.           Order_WriteVisitSequence(Class);
  624.         }
  625.         break;
  626.       case 'F':;
  627.       case 'f':;
  628.         if (Class != Tree_NoTree && 1 <= a && a <= Class->U_1.V_5.Class.InstCount && 1 <= b && b <= Class->U_1.V_5.Class.InstCount) {
  629.           FindPath(a, b, Class);
  630.         }
  631.         break;
  632.       case 'M':;
  633.       case 'm':;
  634.         Tree_WriteClass(Class);
  635.         break;
  636.       case 'Q':;
  637.         Tree_QueryTree(t);
  638.         break;
  639.       case 'q':;
  640.         Tree_QueryTree(Class);
  641.         break;
  642.       case 'h':;
  643.       case 'H':;
  644.         Menue();
  645.         break;
  646.       case 'x':;
  647.       case 'X':;
  648.         goto EXIT_1;
  649.         break;
  650.       case '?':;
  651.         IO_WriteS((System_tFile)IO_StdOutput, (STRING)"node type: ", 11L);
  652.         if (Class != Tree_NoTree) {
  653.           {
  654.             register Tree_yClass *W_14 = &Class->U_1.V_5.Class;
  655.  
  656.             Idents_WriteIdent((System_tFile)IO_StdOutput, W_14->Name);
  657.             IO_WriteS((System_tFile)IO_StdOutput, (STRING)", a: ", 5L);
  658.             if (1 <= a && a <= Class->U_1.V_5.Class.InstCount) {
  659.               Tree_WriteName(W_14->Instance->A[a - 1]);
  660.               IO_WriteS((System_tFile)IO_StdOutput, (STRING)" = ", 3L);
  661.               IO_WriteI((System_tFile)IO_StdOutput, (LONGINT)a, 0L);
  662.             } else {
  663.               IO_WriteS((System_tFile)IO_StdOutput, (STRING)"?", 1L);
  664.             }
  665.             IO_WriteS((System_tFile)IO_StdOutput, (STRING)", b: ", 5L);
  666.             if (1 <= b && b <= Class->U_1.V_5.Class.InstCount) {
  667.               Tree_WriteName(W_14->Instance->A[b - 1]);
  668.               IO_WriteS((System_tFile)IO_StdOutput, (STRING)" = ", 3L);
  669.               IO_WriteI((System_tFile)IO_StdOutput, (LONGINT)b, 0L);
  670.             } else {
  671.               IO_WriteS((System_tFile)IO_StdOutput, (STRING)"?", 1L);
  672.             }
  673.           }
  674.         } else {
  675.           IO_WriteS((System_tFile)IO_StdOutput, (STRING)"?, a: ?, b: ?", 13L);
  676.         }
  677.         IO_WriteNl((System_tFile)IO_StdOutput);
  678.         break;
  679.       default :
  680.         Strings_ArrayToString(Name0.A, 65L, &String);
  681.         Ident = Idents_MakeIdent(&String);
  682.         Class = Tree_IdentifyClass(t->U_1.V_26.Ag.Classes, Ident);
  683.         if (Class == Tree_NoTree) {
  684.           IO_WriteS((System_tFile)IO_StdOutput, (STRING)"unknown node type: ", 19L);
  685.           Strings_WriteL((System_tFile)IO_StdOutput, &String);
  686.         }
  687.         break;
  688.       }
  689.     } else {
  690.       Strings_ArrayToString(Name0.A, 65L, &String);
  691.       Ident = Idents_MakeIdent(&String);
  692.       Class = Tree_IdentifyClass(t->U_1.V_26.Ag.Classes, Ident);
  693.       if (Class == Tree_NoTree) {
  694.         IO_WriteS((System_tFile)IO_StdOutput, (STRING)"unknown node type: ", 19L);
  695.         Strings_WriteL((System_tFile)IO_StdOutput, &String);
  696.       }
  697.     }
  698.   } EXIT_1:;
  699. }
  700.  
  701. void BEGIN_Dialog()
  702. {
  703.   static BOOLEAN has_been_called = FALSE;
  704.  
  705.   if (!has_been_called) {
  706.     has_been_called = TRUE;
  707.  
  708.     BEGIN_Tree();
  709.     BEGIN_DynArray();
  710.     BEGIN_IO();
  711.     BEGIN_Strings();
  712.     BEGIN_Idents();
  713.     BEGIN_Sets();
  714.     BEGIN_Relations();
  715.     BEGIN_Tree();
  716.     BEGIN_Order();
  717.     BEGIN_Tree();
  718.  
  719.   }
  720. }
  721.